using System;
using System.ComponentModel;
using System.Threading;
using FU.Capstones.IMS.Web.Common.InventoryServiceProxy.DataContracts;
using FU.Capstones.IMS.Web.Common.InventoryServiceProxy.EventArgs;
using FU.Capstones.IMS.Web.Common.InventoryServiceProxy.Interfaces;
using FU.Capstones.IMS.Web.Common.InventoryServiceProxy.Respondents;

namespace FU.Capstones.IMS.Web.Common.InventoryServiceProxy.OperationContracts
{
    public partial class InventoryServiceClient
    {

        #region GetEmploymentTypeCollection

        public event EventHandler<CollectionFeedbackCompletedEventArgs<EmploymentType>> GetEmploymentTypeCollectionCompleted;

        [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
        IAsyncResult IInventoryService.BeginGetEmploymentTypeCollection(bool isShowAll, AsyncCallback callback, object asyncState)
        {
            return Channel.BeginGetEmploymentTypeCollection(isShowAll, callback, asyncState);
        }

        [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
        CollectionFeedback<EmploymentType> IInventoryService.EndGetEmploymentTypeCollection(IAsyncResult result)
        {
            return Channel.EndGetEmploymentTypeCollection(result);
        }

        private IAsyncResult OnBeginGetEmploymentTypeCollection(object[] inValues, AsyncCallback callback, object asyncState)
        {
            bool isShowAll = (bool)inValues[0];

            return ((IInventoryService)(this)).BeginGetEmploymentTypeCollection(isShowAll, callback, asyncState);
        }

        private object[] OnEndGetEmploymentTypeCollection(IAsyncResult result)
        {
            CollectionFeedback<EmploymentType> retVal = ((IInventoryService)(this)).EndGetEmploymentTypeCollection(result);
            return new object[] { retVal };
        }

        private void OnGetEmploymentTypeCollectionCompleted(object state)
        {
            if ((GetEmploymentTypeCollectionCompleted != null))
            {
                InvokeAsyncCompletedEventArgs e = ((InvokeAsyncCompletedEventArgs)(state));
                GetEmploymentTypeCollectionCompleted(this, new CollectionFeedbackCompletedEventArgs<EmploymentType>(e.Results, e.Error, e.Cancelled, e.UserState));
            }
        }

        public void GetEmploymentTypeCollectionAsync(bool isShowAll)
        {
            GetEmploymentTypeCollectionAsync(isShowAll, null);
        }

        public void GetEmploymentTypeCollectionAsync(bool isShowAll, object userState)
        {
            if ((onBeginGetEmploymentTypeCollectionDelegate == null))
            {
                onBeginGetEmploymentTypeCollectionDelegate = new BeginOperationDelegate(OnBeginGetEmploymentTypeCollection);
            }
            if ((onEndGetEmploymentTypeCollectionDelegate == null))
            {
                onEndGetEmploymentTypeCollectionDelegate = new EndOperationDelegate(OnEndGetEmploymentTypeCollection);
            }
            if ((onGetEmploymentTypeCollectionCompletedDelegate == null))
            {
                onGetEmploymentTypeCollectionCompletedDelegate = new SendOrPostCallback(OnGetEmploymentTypeCollectionCompleted);
            }
            InvokeAsync(onBeginGetEmploymentTypeCollectionDelegate, new object[] {
                    isShowAll}, onEndGetEmploymentTypeCollectionDelegate, onGetEmploymentTypeCollectionCompletedDelegate, userState);
        }

        private BeginOperationDelegate onBeginGetEmploymentTypeCollectionDelegate;

        private EndOperationDelegate onEndGetEmploymentTypeCollectionDelegate;

        private SendOrPostCallback onGetEmploymentTypeCollectionCompletedDelegate;

        private partial class InventoryServiceClientChannel
        {
            public IAsyncResult BeginGetEmploymentTypeCollection(bool isShowAll, AsyncCallback callback, object asyncState)
            {
                object[] _args = new object[1];
                _args[0] = isShowAll;

                IAsyncResult _result = BeginInvoke("GetEmploymentTypeCollection", _args, callback, asyncState);
                return _result;
            }

            public CollectionFeedback<EmploymentType> EndGetEmploymentTypeCollection(IAsyncResult result)
            {
                object[] _args = new object[0];
                CollectionFeedback<EmploymentType> _result = ((CollectionFeedback<EmploymentType>)(EndInvoke("GetEmploymentTypeCollection", _args, result)));
                return _result;
            }
        }

        #endregion
        
        #region GetSingleEmploymentType

        public event EventHandler<SingleFeedbackCompletedEventArgs<EmploymentType>> GetSingleEmploymentTypeCompleted;

        [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
        IAsyncResult IInventoryService.BeginGetSingleEmploymentType(int employmentTypeID, AsyncCallback callback, object asyncState)
        {
            return Channel.BeginGetSingleEmploymentType(employmentTypeID, callback, asyncState);
        }

        [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
        SingleFeedback<EmploymentType> IInventoryService.EndGetSingleEmploymentType(IAsyncResult result)
        {
            return Channel.EndGetSingleEmploymentType(result);
        }

        private IAsyncResult OnBeginGetSingleEmploymentType(object[] inValues, AsyncCallback callback, object asyncState)
        {
            int employmentTypeID = (int)inValues[0];

            return ((IInventoryService)(this)).BeginGetSingleEmploymentType(employmentTypeID, callback, asyncState);
        }

        private object[] OnEndGetSingleEmploymentType(IAsyncResult result)
        {
            SingleFeedback<EmploymentType> retVal = ((IInventoryService)(this)).EndGetSingleEmploymentType(result);
            return new object[] { retVal };
        }

        private void OnGetSingleEmploymentTypeCompleted(object state)
        {
            if ((GetSingleEmploymentTypeCompleted != null))
            {
                InvokeAsyncCompletedEventArgs e = ((InvokeAsyncCompletedEventArgs)(state));
                GetSingleEmploymentTypeCompleted(this, new SingleFeedbackCompletedEventArgs<EmploymentType>(e.Results, e.Error, e.Cancelled, e.UserState));
            }
        }

        public void GetSingleEmploymentTypeAsync(int employmentTypeID)
        {
            GetSingleEmploymentTypeAsync(employmentTypeID, null);
        }

        public void GetSingleEmploymentTypeAsync(int employmentTypeID, object userState)
        {
            if ((onBeginGetSingleEmploymentTypeDelegate == null))
            {
                onBeginGetSingleEmploymentTypeDelegate = new BeginOperationDelegate(OnBeginGetSingleEmploymentType);
            }
            if ((onEndGetSingleEmploymentTypeDelegate == null))
            {
                onEndGetSingleEmploymentTypeDelegate = new EndOperationDelegate(OnEndGetSingleEmploymentType);
            }
            if ((onGetSingleEmploymentTypeCompletedDelegate == null))
            {
                onGetSingleEmploymentTypeCompletedDelegate = new SendOrPostCallback(OnGetSingleEmploymentTypeCompleted);
            }
            InvokeAsync(onBeginGetSingleEmploymentTypeDelegate, new object[] {
                                                                                         employmentTypeID}, onEndGetSingleEmploymentTypeDelegate, onGetSingleEmploymentTypeCompletedDelegate, userState);
        }

        private BeginOperationDelegate onBeginGetSingleEmploymentTypeDelegate;

        private EndOperationDelegate onEndGetSingleEmploymentTypeDelegate;

        private SendOrPostCallback onGetSingleEmploymentTypeCompletedDelegate;

        private partial class InventoryServiceClientChannel
        {
            public IAsyncResult BeginGetSingleEmploymentType(int employmentTypeID, AsyncCallback callback, object asyncState)
            {
                object[] _args = new object[1];
                _args[0] = employmentTypeID;

                IAsyncResult _result = BeginInvoke("GetSingleEmploymentType", _args, callback, asyncState);
                return _result;
            }

            public SingleFeedback<EmploymentType> EndGetSingleEmploymentType(IAsyncResult result)
            {
                object[] _args = new object[0];
                SingleFeedback<EmploymentType> _result = ((SingleFeedback<EmploymentType>)(EndInvoke("GetSingleEmploymentType", _args, result)));
                return _result;
            }
        }

        #endregion

        #region InsertEmploymentType

        public event EventHandler<SingleFeedbackCompletedEventArgs<int>> InsertEmploymentTypeCompleted;

        [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
        IAsyncResult IInventoryService.BeginInsertEmploymentType(EmploymentType data, AsyncCallback callback, object asyncState)
        {
            return Channel.BeginInsertEmploymentType(data, callback, asyncState);
        }

        [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
        SingleFeedback<int> IInventoryService.EndInsertEmploymentType(IAsyncResult result)
        {
            return Channel.EndInsertEmploymentType(result);
        }

        private IAsyncResult OnBeginInsertEmploymentType(object[] inValues, AsyncCallback callback, object asyncState)
        {
            EmploymentType data = (EmploymentType)inValues[0];

            return ((IInventoryService)(this)).BeginInsertEmploymentType(data, callback, asyncState);
        }

        private object[] OnEndInsertEmploymentType(IAsyncResult result)
        {
            SingleFeedback<int> retVal = ((IInventoryService)(this)).EndInsertEmploymentType(result);
            return new object[] { retVal };
        }

        private void OnInsertEmploymentTypeCompleted(object state)
        {
            if ((InsertEmploymentTypeCompleted != null))
            {
                InvokeAsyncCompletedEventArgs e = ((InvokeAsyncCompletedEventArgs)(state));
                InsertEmploymentTypeCompleted(this, new SingleFeedbackCompletedEventArgs<int>(e.Results, e.Error, e.Cancelled, e.UserState));
            }
        }

        public void InsertEmploymentTypeAsync(EmploymentType data)
        {
            InsertEmploymentTypeAsync(data, null);
        }

        public void InsertEmploymentTypeAsync(EmploymentType data, object userState)
        {
            if ((onBeginInsertEmploymentTypeDelegate == null))
            {
                onBeginInsertEmploymentTypeDelegate = new BeginOperationDelegate(OnBeginInsertEmploymentType);
            }
            if ((onEndInsertEmploymentTypeDelegate == null))
            {
                onEndInsertEmploymentTypeDelegate = new EndOperationDelegate(OnEndInsertEmploymentType);
            }
            if ((onInsertEmploymentTypeCompletedDelegate == null))
            {
                onInsertEmploymentTypeCompletedDelegate = new SendOrPostCallback(OnInsertEmploymentTypeCompleted);
            }
            InvokeAsync(onBeginInsertEmploymentTypeDelegate, new object[] {
                                                                                      data}, onEndInsertEmploymentTypeDelegate, onInsertEmploymentTypeCompletedDelegate, userState);
        }

        private BeginOperationDelegate onBeginInsertEmploymentTypeDelegate;

        private EndOperationDelegate onEndInsertEmploymentTypeDelegate;

        private SendOrPostCallback onInsertEmploymentTypeCompletedDelegate;

        private partial class InventoryServiceClientChannel
        {
            public IAsyncResult BeginInsertEmploymentType(EmploymentType data, AsyncCallback callback, object asyncState)
            {
                object[] _args = new object[1];
                _args[0] = data;

                IAsyncResult _result = BeginInvoke("InsertEmploymentType", _args, callback, asyncState);
                return _result;
            }

            public SingleFeedback<int> EndInsertEmploymentType(IAsyncResult result)
            {
                object[] _args = new object[0];
                SingleFeedback<int> _result = ((SingleFeedback<int>)(EndInvoke("InsertEmploymentType", _args, result)));
                return _result;
            }
        }

        #endregion

        #region UpdateEmploymentType

        public event EventHandler<FeedbackCompletedEventArgs> UpdateEmploymentTypeCompleted;

        [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
        IAsyncResult IInventoryService.BeginUpdateEmploymentType(EmploymentType data, AsyncCallback callback, object asyncState)
        {
            return Channel.BeginUpdateEmploymentType(data, callback, asyncState);
        }

        [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
        Feedback IInventoryService.EndUpdateEmploymentType(IAsyncResult result)
        {
            return Channel.EndUpdateEmploymentType(result);
        }

        private IAsyncResult OnBeginUpdateEmploymentType(object[] inValues, AsyncCallback callback, object asyncState)
        {
            EmploymentType data = (EmploymentType)inValues[0];

            return ((IInventoryService)(this)).BeginUpdateEmploymentType(data, callback, asyncState);
        }

        private object[] OnEndUpdateEmploymentType(IAsyncResult result)
        {
            Feedback retVal = ((IInventoryService)(this)).EndUpdateEmploymentType(result);
            return new object[] { retVal };
        }

        private void OnUpdateEmploymentTypeCompleted(object state)
        {
            if ((UpdateEmploymentTypeCompleted != null))
            {
                InvokeAsyncCompletedEventArgs e = ((InvokeAsyncCompletedEventArgs)(state));
                UpdateEmploymentTypeCompleted(this, new FeedbackCompletedEventArgs(e.Results, e.Error, e.Cancelled, e.UserState));
            }
        }

        public void UpdateEmploymentTypeAsync(EmploymentType data)
        {
            UpdateEmploymentTypeAsync(data, null);
        }

        public void UpdateEmploymentTypeAsync(EmploymentType data, object userState)
        {
            if ((onBeginUpdateEmploymentTypeDelegate == null))
            {
                onBeginUpdateEmploymentTypeDelegate = new BeginOperationDelegate(OnBeginUpdateEmploymentType);
            }
            if ((onEndUpdateEmploymentTypeDelegate == null))
            {
                onEndUpdateEmploymentTypeDelegate = new EndOperationDelegate(OnEndUpdateEmploymentType);
            }
            if ((onUpdateEmploymentTypeCompletedDelegate == null))
            {
                onUpdateEmploymentTypeCompletedDelegate = new SendOrPostCallback(OnUpdateEmploymentTypeCompleted);
            }
            InvokeAsync(onBeginUpdateEmploymentTypeDelegate, new object[] {
                                                                                      data}, onEndUpdateEmploymentTypeDelegate, onUpdateEmploymentTypeCompletedDelegate, userState);
        }

        private BeginOperationDelegate onBeginUpdateEmploymentTypeDelegate;

        private EndOperationDelegate onEndUpdateEmploymentTypeDelegate;

        private SendOrPostCallback onUpdateEmploymentTypeCompletedDelegate;

        private partial class InventoryServiceClientChannel
        {
            public IAsyncResult BeginUpdateEmploymentType(EmploymentType data, AsyncCallback callback, object asyncState)
            {
                object[] _args = new object[1];
                _args[0] = data;

                IAsyncResult _result = BeginInvoke("UpdateEmploymentType", _args, callback, asyncState);
                return _result;
            }

            public Feedback EndUpdateEmploymentType(IAsyncResult result)
            {
                object[] _args = new object[0];
                Feedback _result = ((Feedback)(EndInvoke("UpdateEmploymentType", _args, result)));
                return _result;
            }
        }

        #endregion

        #region DeleteEmploymentType

        public event EventHandler<FeedbackCompletedEventArgs> DeleteEmploymentTypeCompleted;

        [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
        IAsyncResult IInventoryService.BeginDeleteEmploymentType(int data, AsyncCallback callback, object asyncState)
        {
            return Channel.BeginDeleteEmploymentType(data, callback, asyncState);
        }

        [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
        Feedback IInventoryService.EndDeleteEmploymentType(IAsyncResult result)
        {
            return Channel.EndDeleteEmploymentType(result);
        }

        private IAsyncResult OnBeginDeleteEmploymentType(object[] inValues, AsyncCallback callback, object asyncState)
        {
            int data = (int)inValues[0];

            return ((IInventoryService)(this)).BeginDeleteEmploymentType(data, callback, asyncState);
        }

        private object[] OnEndDeleteEmploymentType(IAsyncResult result)
        {
            Feedback retVal = ((IInventoryService)(this)).EndDeleteEmploymentType(result);
            return new object[] { retVal };
        }

        private void OnDeleteEmploymentTypeCompleted(object state)
        {
            if ((DeleteEmploymentTypeCompleted != null))
            {
                InvokeAsyncCompletedEventArgs e = ((InvokeAsyncCompletedEventArgs)(state));
                DeleteEmploymentTypeCompleted(this, new FeedbackCompletedEventArgs(e.Results, e.Error, e.Cancelled, e.UserState));
            }
        }

        public void DeleteEmploymentTypeAsync(int data)
        {
            DeleteEmploymentTypeAsync(data, null);
        }

        public void DeleteEmploymentTypeAsync(int data, object userState)
        {
            if ((onBeginDeleteEmploymentTypeDelegate == null))
            {
                onBeginDeleteEmploymentTypeDelegate = new BeginOperationDelegate(OnBeginDeleteEmploymentType);
            }
            if ((onEndDeleteEmploymentTypeDelegate == null))
            {
                onEndDeleteEmploymentTypeDelegate = new EndOperationDelegate(OnEndDeleteEmploymentType);
            }
            if ((onDeleteEmploymentTypeCompletedDelegate == null))
            {
                onDeleteEmploymentTypeCompletedDelegate = new SendOrPostCallback(OnDeleteEmploymentTypeCompleted);
            }
            InvokeAsync(onBeginDeleteEmploymentTypeDelegate, new object[] {
                                                                                      data}, onEndDeleteEmploymentTypeDelegate, onDeleteEmploymentTypeCompletedDelegate, userState);
        }

        private BeginOperationDelegate onBeginDeleteEmploymentTypeDelegate;

        private EndOperationDelegate onEndDeleteEmploymentTypeDelegate;

        private SendOrPostCallback onDeleteEmploymentTypeCompletedDelegate;

        private partial class InventoryServiceClientChannel
        {
            public IAsyncResult BeginDeleteEmploymentType(int data, AsyncCallback callback, object asyncState)
            {
                object[] _args = new object[1];
                _args[0] = data;

                IAsyncResult _result = BeginInvoke("DeleteEmploymentType", _args, callback, asyncState);
                return _result;
            }

            public Feedback EndDeleteEmploymentType(IAsyncResult result)
            {
                object[] _args = new object[0];
                Feedback _result = ((Feedback)(EndInvoke("DeleteEmploymentType", _args, result)));
                return _result;
            }
        }

        #endregion

        #region SearchEmploymentType

        public event EventHandler<CollectionFeedbackCompletedEventArgs<EmploymentType>> SearchEmploymentTypeCompleted;

        [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
        IAsyncResult IInventoryService.BeginSearchEmploymentType(EmploymentType criteria, AsyncCallback callback, object asyncState)
        {
            return Channel.BeginSearchEmploymentType(criteria, callback, asyncState);
        }

        [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
        CollectionFeedback<EmploymentType> IInventoryService.EndSearchEmploymentType(IAsyncResult result)
        {
            return Channel.EndSearchEmploymentType(result);
        }

        private IAsyncResult OnBeginSearchEmploymentType(object[] inValues, AsyncCallback callback, object asyncState)
        {
            EmploymentType criteria = (EmploymentType)inValues[0];

            return ((IInventoryService)(this)).BeginSearchEmploymentType(criteria, callback, asyncState);
        }

        private object[] OnEndSearchEmploymentType(IAsyncResult result)
        {
            CollectionFeedback<EmploymentType> retVal = ((IInventoryService)(this)).EndSearchEmploymentType(result);
            return new object[] { retVal };
        }

        private void OnSearchEmploymentTypeCompleted(object state)
        {
            if ((SearchEmploymentTypeCompleted != null))
            {
                InvokeAsyncCompletedEventArgs e = ((InvokeAsyncCompletedEventArgs)(state));
                SearchEmploymentTypeCompleted(this, new CollectionFeedbackCompletedEventArgs<EmploymentType>(e.Results, e.Error, e.Cancelled, e.UserState));
            }
        }

        public void SearchEmploymentTypeAsync(EmploymentType criteria)
        {
            SearchEmploymentTypeAsync(criteria, null);
        }

        public void SearchEmploymentTypeAsync(EmploymentType criteria, object userState)
        {
            if ((onBeginSearchEmploymentTypeDelegate == null))
            {
                onBeginSearchEmploymentTypeDelegate = new BeginOperationDelegate(OnBeginSearchEmploymentType);
            }
            if ((onEndSearchEmploymentTypeDelegate == null))
            {
                onEndSearchEmploymentTypeDelegate = new EndOperationDelegate(OnEndSearchEmploymentType);
            }
            if ((onSearchEmploymentTypeCompletedDelegate == null))
            {
                onSearchEmploymentTypeCompletedDelegate = new SendOrPostCallback(OnSearchEmploymentTypeCompleted);
            }
            InvokeAsync(onBeginSearchEmploymentTypeDelegate, new object[] {
                                                                                      criteria}, onEndSearchEmploymentTypeDelegate, onSearchEmploymentTypeCompletedDelegate, userState);
        }

        private BeginOperationDelegate onBeginSearchEmploymentTypeDelegate;

        private EndOperationDelegate onEndSearchEmploymentTypeDelegate;

        private SendOrPostCallback onSearchEmploymentTypeCompletedDelegate;

        private partial class InventoryServiceClientChannel
        {
            public IAsyncResult BeginSearchEmploymentType(EmploymentType criteria, AsyncCallback callback, object asyncState)
            {
                object[] _args = new object[1];
                _args[0] = criteria;

                IAsyncResult _result = BeginInvoke("SearchEmploymentType", _args, callback, asyncState);
                return _result;
            }

            public CollectionFeedback<EmploymentType> EndSearchEmploymentType(IAsyncResult result)
            {
                object[] _args = new object[0];
                CollectionFeedback<EmploymentType> _result = ((CollectionFeedback<EmploymentType>)(EndInvoke("SearchEmploymentType", _args, result)));
                return _result;
            }
        }

        #endregion

        #region UndoDeleteEmploymentType

        public event EventHandler<FeedbackCompletedEventArgs> UndoDeleteEmploymentTypeCompleted;

        [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
        IAsyncResult IInventoryService.BeginUndoDeleteEmploymentType(int objID, AsyncCallback callback, object asyncState)
        {
            return Channel.BeginUndoDeleteEmploymentType(objID, callback, asyncState);
        }

        [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]
        Feedback IInventoryService.EndUndoDeleteEmploymentType(IAsyncResult result)
        {
            return Channel.EndUndoDeleteEmploymentType(result);
        }

        private IAsyncResult OnBeginUndoDeleteEmploymentType(object[] inValues, AsyncCallback callback, object asyncState)
        {
            int objID = (int)inValues[0];

            return ((IInventoryService)(this)).BeginUndoDeleteEmploymentType(objID, callback, asyncState);
        }

        private object[] OnEndUndoDeleteEmploymentType(IAsyncResult result)
        {
            Feedback retVal = ((IInventoryService)(this)).EndUndoDeleteEmploymentType(result);
            return new object[] { retVal };
        }

        private void OnUndoDeleteEmploymentTypeCompleted(object state)
        {
            if ((UndoDeleteEmploymentTypeCompleted != null))
            {
                InvokeAsyncCompletedEventArgs e = ((InvokeAsyncCompletedEventArgs)(state));
                UndoDeleteEmploymentTypeCompleted(this, new FeedbackCompletedEventArgs(e.Results, e.Error, e.Cancelled, e.UserState));
            }
        }

        public void UndoDeleteEmploymentTypeAsync(int objID)
        {
            UndoDeleteEmploymentTypeAsync(objID, null);
        }

        public void UndoDeleteEmploymentTypeAsync(int objID, object userState)
        {
            if ((onBeginUndoDeleteEmploymentTypeDelegate == null))
            {
                onBeginUndoDeleteEmploymentTypeDelegate = new BeginOperationDelegate(OnBeginUndoDeleteEmploymentType);
            }
            if ((onEndUndoDeleteEmploymentTypeDelegate == null))
            {
                onEndUndoDeleteEmploymentTypeDelegate = new EndOperationDelegate(OnEndUndoDeleteEmploymentType);
            }
            if ((onUndoDeleteEmploymentTypeCompletedDelegate == null))
            {
                onUndoDeleteEmploymentTypeCompletedDelegate = new SendOrPostCallback(OnUndoDeleteEmploymentTypeCompleted);
            }
            InvokeAsync(onBeginUndoDeleteEmploymentTypeDelegate, new object[] {
                    objID}, onEndUndoDeleteEmploymentTypeDelegate, onUndoDeleteEmploymentTypeCompletedDelegate, userState);
        }

        private BeginOperationDelegate onBeginUndoDeleteEmploymentTypeDelegate;

        private EndOperationDelegate onEndUndoDeleteEmploymentTypeDelegate;

        private SendOrPostCallback onUndoDeleteEmploymentTypeCompletedDelegate;

        private partial class InventoryServiceClientChannel
        {
            public IAsyncResult BeginUndoDeleteEmploymentType(int objID, AsyncCallback callback, object asyncState)
            {
                object[] _args = new object[1];
                _args[0] = objID;

                IAsyncResult _result = BeginInvoke("UndoDeleteEmploymentType", _args, callback, asyncState);
                return _result;
            }

            public Feedback EndUndoDeleteEmploymentType(IAsyncResult result)
            {
                object[] _args = new object[0];
                Feedback _result = ((Feedback)(EndInvoke("UndoDeleteEmploymentType", _args, result)));
                return _result;
            }
        }

        #endregion
        

    }
}